<<<<<<< .mine
/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package tasks;

import java.io.*;

public class Process implements ProcessIntrface, Serializable {
    private int pId; // идентификатор процеса
    private int threadQuantity; // максимальное кол-во потоков в процессе
    private Thread[] threads; // массив для хранения элементов очереди
    private int first; // индекс первого элемента очереди
    private int last; // индекс элемента, следующего за последним в очереди
    private int size; // текущий размер очереди

    // конструктор принимает: 
    // идентификатор процесса, главного потока процесса, максимальное кол-во потоков создаваемого процесса
    // генерирует исключение, если макс. кол-во потоков < 1
    public Process(int pId, int mainTId, int threadQ) throws InputErrorException { 
        if (threadQ == 0) {
            throw new InputErrorException("Threads quantity most be more than zero"); //поток у процесса должен быть хотя бы один
        }
        threadQuantity = threadQ; // установили макс. кол-во потоков процесса
        threads = new Thread[threadQuantity]; // создали массив длинной равной макс. кол-ву потоков
        this.pId = pId; // установили идентификатор пороцесса
        first = last = 0; // установили индексы первого и последнего элемента в 0
        this.createThread(mainTId); // вызвали создание главного потока с указанным идентификатором
    }

    public int quantityOfThreads() {
        return size; // возвращает текущее кол-во потоков процесса
    }

    public boolean isOneThreaded() {
        return size == 1; // проверяет, у процесса только главный поток?
    }

    public boolean isFull() {
        return size == threadQuantity; // проверяет, полна ли очередь потоков?
    }
    
    
    // создаем поток у процесса - добавляем в очередь, принимает идентификатор создаваемого потока,
    // генерирует исключение, если очередь потоков полна
    public void createThread(int tId) throws FullException {
        if (this.isFull()) throw new FullException("To many threads");
        Thread newThread = new Thread(tId); // создаем поток
        threads[last] = newThread; // устанавливаем его в конец очереди
        last += 1; // индекс элемента, следующего за последним в очереди +1
        if (last == threadQuantity) { // если индекс следующего за последним стал равен макс. кол-ву -
            last = 0; // - потоков(длинне массива), то выставляем его в 0
        }
        size += 1; // увеличили поле размера очереди
        
    }
    
    // завершаем очередной поток процесса, если потоков больше одного, иначе - исключение
    public Thread killThread() throws OneThreadedException {
        if (this.isOneThreaded()) throw new OneThreadedException("Can't kill main thread - kill process");
        Thread killedThread = threads[first]; // устанавливаем возвращаемый элемент равным первому потоку очереди
        threads[first] = null; // первому элементу очереди присваиваем null
        first += 1; // индекс первого элемента очереди смещаем на один вправо(+1)
            if (first == threadQuantity) { // если индекс первого стал равен макс. кол-ву -
                first = 0; // - потоков(длинне массива), то выставляем его в 0
            }
            size -= 1; // уменьшили текущее кол-во потоков на 1
        return killedThread;
    }
    
    //возвращаем состояние очереди потоков процесса
    public String returnThreadsState() {
        StringBuilder temp = new StringBuilder();
        if ((first+size)<= threadQuantity) { // если конец очереди не обгоняет начало(относительно индексов в массиве)
            for (int i = first; i < (first+size); i++) { // проходим от первого элемента до последнего
                temp.append(threads[i].getId()); // добавляем идентификатор очередного потока
                temp.append("(");
                temp.append(threads[i].getState()); // и его состояние в "скобочках"
                temp.append(") ");
            }
        }
        else { // если индекс конца все таки обогнал
            for (int i = first; i < threadQuantity; i++) { // от первого элемента очереди и до конца массива делаем тоже, что и выше
                temp.append(threads[i].getId());
                temp.append("(");
                temp.append(threads[i].getState());
                temp.append(") ");
            }
            for (int i = 0; i< last; i++) { // затем от начала массива до конца очереди, продолжаем делать что и выше
                temp.append(threads[i].getId());
                temp.append("(");
                temp.append(threads[i].getState());
                temp.append(") ");
            }
        }
        return temp.toString(); // в конечном итоге возвращаем состояние очереди в виде строки
    }
    
    // процесс поиска совершенно аналогичен возврату состояния очереди, за исключением того, 
    // что процесс поиска прерывается при нахождении первого вхождения потока с заданным идентификатором 
    // в очередь потоков, с случае если нужный поток не найден генерируется исключение
    public Thread find(int findId) throws NotFoundException {
        int i = first;
        if ((first + size) <= threadQuantity) {
            while ((i < size) && (threads[i].getId()!= findId)) {
                i++;
            }
        } else {
            while ((i < threadQuantity) && (threads[i].getId()!= findId)) i++;
            if (threads[i].getId() == findId) {
                return threads[i];
            }
            else {
                i = 0;
                while ((i < last) && (threads[i].getId()!= findId)) i++; 
            }
        }
        if ((i >= size)||(threads[i] == null)||(threads[i].getId()!= findId)) {
                throw new NotFoundException("Thread with id:" + findId + " not found");
            }
            else return threads[i]; // возвращаем найденный поток
    }

    public int getId() { // геттер идентификатора процесса 
        return pId;
    }

}
=======
/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package kurs;

import java.io.*;

/**
 *
 * @author Matrix
 */
public class Process implements ProcessIntrface, Serializable {
    private int pId;
    private int threadQuantity;
    private Thread[] threads;
    private int first;
    private int last;
    private int size;

    public Process(int pId, int mainTId, int threadQ) throws InputErrorException {
        if (threadQ == 0) {
            throw new InputErrorException("Threads quantity most be more than zero"); //поток у процесса должен быть хотя бы один
        }
        threadQuantity = threadQ;
        threads = new Thread[threadQuantity];
        this.pId = pId;
        first = last = 0;
        this.createThread(mainTId);
    }

    public int quantityOfThreads() {
        return size;
    }

    public boolean isOneThreaded() {
        return size == 1;
    }

    public boolean isFull() {
        return size == threadQuantity;
    }
    

    public void createThread(int tId) throws FullException {
        if (this.isFull()) throw new FullException("To many threads");
        Thread newThread = new Thread(tId);
        threads[last] = newThread;
        last += 1;
        if (last == threadQuantity) {
            last = 0;
        }
        size += 1;
        
    }

    public Thread killThread() throws OneThreadedException {
        if (this.isOneThreaded()) throw new OneThreadedException("Can't kill main thread - kill process");
        Thread killedThread = threads[first];
        threads[first] = null;
        first += 1;
            if (first == threadQuantity) {
                first = 0;
            }
            size -= 1;
        return killedThread;
    }

    public String returnThreadsState() {
        StringBuilder temp = new StringBuilder();
        if ((first+size)<= threadQuantity) {
            for (int i = first; i < (first+size); i++) {
                temp.append(threads[i].getId());
                temp.append("(");
                temp.append(threads[i].getState());
                temp.append(") ");
            }
        }
        else {
            for (int i = first; i < threadQuantity; i++) {
                temp.append(threads[i].getId());
                temp.append("(");
                temp.append(threads[i].getState());
                temp.append(") ");
            }
            for (int i = 0; i< last; i++) {
                temp.append(threads[i].getId());
                temp.append("(");
                temp.append(threads[i].getState());
                temp.append(") ");
            }
        }
        return temp.toString();
    };

    public Thread find(int findId) throws NotFoundException {
        int i = first;
        if ((first + size) <= threadQuantity) {
            while ((i < size) && (threads[i].getId()!= findId)) {
                i++;
            }
        } else {
            while ((i < threadQuantity) && (threads[i].getId()!= findId)) i++;
            if (threads[i].getId() == findId) {
                return threads[i];
            }
            else {
                i = 0;
                while ((i < last) && (threads[i].getId()!= findId)) i++; 
            }
        }
        if ((i >= size)||(threads[i] == null)||(threads[i].getId()!= findId)) {
                throw new NotFoundException("Thread with id:" + findId + " not found");
            }
            else return threads[i];
    }

    /**
     * @return the pId
     */
    public int getId() {
        return pId;
    }

}
>>>>>>> .r60
